@itpay/cli 0.2.1 → 0.2.3

package/README.md

@@ -158,6 +158,19 @@ Before starting a new purchase, agents should inspect recoverable local state:
 itp status --refresh --json
 ```
 
+Humans can use the default account overview:
+
+```bash
+itp status
+```
+
+```text
+Account:  buyer_7xK2mP9vQ4
+Linked:   alipay, wechat
+Orders:   12
+Device:   Codex on MacBook-Pro (active)
+```
+
 If an unfinished run exists, continue it:
 
 ```bash
@@ -208,7 +221,7 @@ itp buyer checkout status <checkout_id> --json
 For the one-command buyer helper:
 
 ```bash
-itp buy var_itpay_enterprise_fuzzy_search_cny01 --email buyer@example.com --input company_name=阿里 --json
+itp buy var_itpay_enterprise_fuzzy_search_cny01 --email buyer@example.com --input company_name=阿里 --display agent --no-wait-payment --json
 ```
 
 For multi-item cart tests:
@@ -226,6 +239,7 @@ Payment QR rules:
 - Otherwise render the ItPay-hosted `qr_png_url` / `preferred_qr_url`.
 - Use `mobile_wallet_url` only as a human mobile fallback.
 - Do not generate your own QR from payment URLs.
+- In agent app clients, send `payment_handoff.markdown` to the human first, then run `payment_handoff.wait_command`.
 - Treat only `payment_intent.verified` as payment success.
 
 If the human wants the agent to analyze delivered content, the human must reveal

package/bin/itp

@@ -93,7 +93,7 @@ async function main() {
       output({
         version: VERSION,
         commands: [
-          "buy var_pubg_couple_skin_cny20 --sandbox --email buyer@example.com --phone +8613800000000 --json",
+          "buy var_pubg_couple_skin_cny20 --sandbox --email buyer@example.com --phone +8613800000000 --display agent --no-wait-payment --json",
           "buy var_pubg_couple_skin_cny20 --sandbox --email buyer@example.com --phone +8613800000000 --no-wait --json",
           "buyer catalog search --query 企业工商 --category business_data_api --provider itpay_enterprise_data --json",
           "buyer catalog get --variant var_pubg_couple_skin_cny20 --json",

package/docs/agent/buyer/cart-checkout.json

@@ -68,7 +68,7 @@
     },
     {
       "intent": "do both steps through the high-level command",
-      "command": "itp buy <variant_id> --sandbox --email <buyer_email> --phone <buyer_phone> --json",
+      "command": "itp buy <variant_id> --sandbox --email <buyer_email> --phone <buyer_phone> --display agent --no-wait-payment --json",
       "success_signal": "response.status is waiting_human_auth, waiting_user_payment, payment_verified, or delivery_claimable"
     }
   ],

package/docs/agent/buyer/payment-qr.json

@@ -17,8 +17,8 @@
   "commands": [
     {
       "intent": "create payment intent through the high-level buy flow",
-      "command": "itp buy <variant_id> --sandbox --email <buyer_email> --phone <buyer_phone> --display agent --json",
-      "success_signal": "response.payment_intent.human_action.local_qr_path or response.payment_intent.human_action.qr_png_url is present"
+      "command": "itp buy <variant_id> --sandbox --email <buyer_email> --phone <buyer_phone> --display agent --no-wait-payment --json",
+      "success_signal": "response.payment_handoff.markdown and response.payment_handoff.wait_command are present"
     },
     {
       "intent": "recover a scanner order-not-found display problem",
@@ -33,6 +33,8 @@
     "Payment QR display requires both a valid/saved buyer session and payment_intent_id. If payment_intent_id appears before buyer_session is saved, run buyer checkout resume/status instead of showing payment QR.",
     "Do not stop after showing auth_qr unless the human explicitly asks you to pause. Keep waiting/resuming the same checkout so the post-auth payment handoff can continue.",
     "Do not describe auth_qr as payment success or payment proof. Only payment_intent.verified proves payment.",
+    "In Codex or Claude Code app clients, the default UX is show-then-wait: show response.payment_handoff.markdown first, then run response.payment_handoff.wait_command.",
+    "For Telegram-style message clients, show response.payment_handoff.markdown and stop unless the human asks you to keep waiting or returns with a payment question.",
     "MUST show local_qr_path first when present. Many agent clients do not reliably render remote QR images; local_qr_path is the most reliable desktop/chat display artifact.",
     "If local_qr_path is not present, show qr_png_url or preferred_qr_url as the primary scannable QR. This is an ItPay-hosted human QR image; it may render the native provider payment code for scanner reliability, but the agent must not request or decode the raw provider payload.",
     "Use qr_image_url/SVG only as a fallback when PNG/local rendering is unavailable.",
@@ -40,7 +42,8 @@
     "payment_entry_url is the stable ItPay status/payment page. qr_png_url/local_qr_path is usually the better desktop scanner artifact.",
     "In Alipay sandbox, the provider can briefly show order not found even after precreate succeeded. Tell the human to wait 30-60 seconds and retry the same QR/page. Do not create a new checkout, do not create a new payment intent, and do not repeatedly refresh unless the ItPay page or CLI explicitly asks for recovery.",
     "Opening the payment page must not be treated as paid.",
-    "After showing QR, immediately wait for payment verification."
+    "Do not run payment wait before the QR/link has been sent to the human.",
+    "After showing QR, run payment_handoff.wait_command or buyer payment wait for the same payment_intent_id."
   ],
   "forbidden": [
     "Do not encode payment_entry_url into a new QR yourself when qr_png_url/local_qr_path is available.",

package/docs/agent/buyer/payment-wait.json

@@ -27,9 +27,11 @@
     }
   ],
   "agent_rules": [
+    "Start payment wait only after the QR image/link has already been sent to the human.",
     "Payment wait is a recovery loop around the same payment_intent_id, not a one-shot command.",
     "wait.timeout is a heartbeat, not a payment failure.",
-    "Continue waiting with the same payment_intent_id unless the user explicitly cancels.",
+    "In Codex or Claude Code app clients, after showing QR, wait online for a short visible cycle first. If the human still has not paid, explain that the same QR/link remains valid and pause for their reply.",
+    "Continue waiting with the same payment_intent_id unless the user explicitly cancels or asks you to pause.",
     "If the network drops, the process is interrupted, or there is no response, rerun payment wait with the same payment_intent_id or run checkout status/resume with the same checkout_id.",
     "If status is unclear, tell the human it is unclear and continue querying the same payment_intent_id/checkout_id. Do not create a new checkout.",
     "Payment success is payment_intent.verified only.",

package/docs/agent/buyer/quickstart.json

@@ -36,8 +36,8 @@
     },
     {
       "intent": "buy a selected variant with the high-level cart-first flow",
-      "command": "itp buy <variant_id> --sandbox --email <buyer_email> --phone <buyer_phone> --json",
-      "success_signal": "response.status becomes waiting_human_auth, waiting_user_payment, payment_verified, or delivery_claimable"
+      "command": "itp buy <variant_id> --sandbox --email <buyer_email> --phone <buyer_phone> --display agent --no-wait-payment --json",
+      "success_signal": "response.status becomes waiting_human_auth or waiting_user_payment; if waiting_user_payment, response.payment_handoff contains markdown and wait_command"
     }
   ],
   "agent_rules": [
@@ -54,8 +54,9 @@
     "After showing auth_qr, keep running/resuming the same checkout unless the human explicitly asks you to pause. Do not stop merely because a QR was displayed.",
     "When a buyer command returns buyer_session.status=buyer_session_saved, the CLI has stored the buyer account session for this agent device. You may continue with checkout/payment or `buyer vault` commands without asking the human for a token.",
     "Vault grants are only for reading approved delivered artifacts. They are not buyer session credentials and do not authorize refunds or account/order management.",
-    "Use high-level itp buy when possible; it is designed to show the first-purchase entry, wait/resume, continue to payment, wait for verification, and poll delivery.",
-    "Show the returned payment QR exactly as provided.",
+    "Use high-level itp buy when possible, but in agent app clients split payment into two visible steps: first return and show payment_handoff, then run payment_handoff.wait_command.",
+    "If response.payment_handoff.markdown is present, send it to the human immediately in the same user-visible message. It includes the QR image and payment link.",
+    "Show the returned payment QR exactly as provided before starting payment wait.",
     "Payment truth comes only from payment_intent.verified.",
     "Secure delivery goes to the human first; report redacted delivery status only."
   ],

package/lib/account-status.js

@@ -0,0 +1,157 @@
+import { coreApi } from "./http.js";
+import { noRecoverableContext } from "./buyer.js";
+import { cliCommand, output, readConfig, readCredentials, readSessionToken, safeErrorMessage } from "./env.js";
+
+async function accountOverviewStatus(flags = {}) {
+  const config = readConfig();
+  const credentials = readCredentials();
+  const hasLocalSession = Boolean(readSessionToken(credentials) || flags.access_token);
+  const base = {
+    schema_version: "itp.agent.v1",
+    status: hasLocalSession ? "account_status_unavailable" : "unauthenticated",
+    phase: hasLocalSession ? "account_status_unavailable" : "unauthenticated",
+    authenticated: false,
+    session_verified: !hasLocalSession,
+    auth_source: hasLocalSession ? "local_files_unverified" : "local_files",
+    account_id: config.account_id || null,
+    buyer_account_id: config.account_id || null,
+    device_id: config.device_id || null,
+    agent_device_id: config.device_id || null,
+    linked_providers: [],
+    order_count: 0,
+    created_at: null,
+    device: config.device_id ? { agent_device_id: config.device_id } : null,
+    next: hasLocalSession
+      ? { type: "retry_status", command: cliCommand("status", "--json"), safe_for_agent: true }
+      : { type: "start_auth", command: cliCommand("setup", "--plan", "credit-300", "--method", "alipay", "--json"), safe_for_agent: true },
+    recoverable_context: noRecoverableContext(),
+    agent_next_actions: hasLocalSession
+      ? ["run_status_refresh", "view_orders", "create_refund_if_needed", "list_agent_read_grants"]
+      : ["start_human_auth_if_unauthenticated"],
+    secrets: { raw_key_included: false, session_token_included: false }
+  };
+  if (!hasLocalSession) return base;
+
+  try {
+    const me = await coreApi("/v1/me", { method: "GET" }, flags);
+    const authenticated = Boolean(me.authenticated);
+    const accountID = me.buyer_account_id || config.account_id || null;
+    const deviceID = me.agent_device_id || me.device?.agent_device_id || config.device_id || null;
+    return {
+      ...base,
+      status: authenticated ? "idle" : "unauthenticated",
+      phase: authenticated ? "idle" : "unauthenticated",
+      authenticated,
+      session_verified: true,
+      auth_source: "core",
+      account_id: accountID,
+      buyer_account_id: accountID,
+      device_id: deviceID,
+      agent_device_id: deviceID,
+      linked_providers: Array.isArray(me.linked_providers) ? me.linked_providers : [],
+      order_count: Number.isFinite(Number(me.order_count)) ? Number(me.order_count) : 0,
+      created_at: me.created_at || null,
+      device: me.device || (deviceID ? { agent_device_id: deviceID } : null),
+      next: authenticated
+        ? { type: "buyer_ready", command: cliCommand("buyer", "auth", "status", "--json"), safe_for_agent: true }
+        : base.next,
+      agent_next_actions: authenticated
+        ? ["search_catalog", "view_orders", "create_refund_if_needed", "list_agent_read_grants"]
+        : ["start_human_auth_if_unauthenticated"],
+      backend: {
+        environment: me.environment || null,
+        backend_version: me.backend_version || null
+      }
+    };
+  } catch (error) {
+    return {
+      ...base,
+      error: safeErrorMessage(error)
+    };
+  }
+}
+
+function outputAccountStatus(status, flags = {}) {
+  if (flags.json) {
+    output(status);
+    return;
+  }
+  console.log(formatStatusText(status));
+}
+
+function formatStatusText(status = {}) {
+  if (!status.authenticated) {
+    const lines = [
+      `Account:  ${status.account_id ? `${status.account_id} (unverified)` : "not signed in"}`,
+      "Linked:   -",
+      "Orders:   -",
+      `Device:   ${formatDeviceLine(status.device, status.device_id) || "-"}`
+    ];
+    if (status.error) lines.push(`Error:    ${status.error}`);
+    return lines.join("\n");
+  }
+  const linked = Array.isArray(status.linked_providers) && status.linked_providers.length
+    ? status.linked_providers.join(", ")
+    : "-";
+  return [
+    `Account:  ${status.buyer_account_id || status.account_id || "-"}`,
+    `Linked:   ${linked}`,
+    `Orders:   ${Number.isFinite(Number(status.order_count)) ? Number(status.order_count) : 0}`,
+    `Device:   ${formatDeviceLine(status.device, status.device_id) || "-"}`
+  ].join("\n");
+}
+
+function formatDeviceLine(device, fallbackID = "") {
+  const displayName = String(device?.display_name || "").trim();
+  const deviceID = String(device?.agent_device_id || fallbackID || "").trim();
+  const label = displayName || deviceID;
+  if (!label) return "";
+  const status = String(device?.status || "").trim();
+  return status ? `${label} (${status})` : label;
+}
+
+async function refreshBuyerSessionForStatus(flags = {}) {
+  const config = readConfig();
+  const credentials = readCredentials();
+  if (!readSessionToken(credentials)) {
+    return {
+      authenticated: false,
+      session_verified: true,
+      account_id: config.account_id || null,
+      device_id: config.device_id || null,
+      auth_source: "core_no_session"
+    };
+  }
+  try {
+    const status = await coreApi("/v1/me/auth/status", { method: "GET" }, flags);
+    return {
+      authenticated: true,
+      session_verified: true,
+      account_id: status.buyer_account_id || config.account_id || null,
+      device_id: config.device_id || null,
+      account_status: status.account_status || null,
+      auth_source: "core"
+    };
+  } catch (error) {
+    return {
+      authenticated: false,
+      session_verified: true,
+      account_id: config.account_id || null,
+      device_id: config.device_id || null,
+      auth_source: "core",
+      error: safeErrorMessage(error)
+    };
+  }
+}
+
+function nextActionForAuthStatus(auth = {}, flags = {}) {
+  if (auth.authenticated && auth.session_verified === false) {
+    return { type: "verify_buyer_session", command: cliCommand("status", "--refresh", "--json"), safe_for_agent: true };
+  }
+  if (auth.authenticated) {
+    return { type: "buyer_ready", command: cliCommand("buyer", "auth", "status", "--json"), safe_for_agent: true };
+  }
+  return { type: "start_auth", command: cliCommand("setup", "--plan", "credit-300", "--method", "alipay", "--json"), safe_for_agent: true };
+}
+
+export { accountOverviewStatus, outputAccountStatus, refreshBuyerSessionForStatus, nextActionForAuthStatus };

package/lib/buyer.js

@@ -4,9 +4,10 @@ import {
   writeCredentials, writeSessionCredentials, writeState
 } from "./env.js";
 import { coreApi, coreApiBase } from "./http.js";
-import { renderHumanAction, renderItPayPaymentAction, writeWaitHeartbeat } from "./render-human.js";
+import { renderHumanAction, renderItPayPaymentAction, shouldReturnAfterAgentTextQR, writeWaitHeartbeat } from "./render-human.js";
 
 async function buyerBuy(flags) {
+  const showThenWait = shouldReturnAfterAgentTextQR(flags);
   const selectionID = flags.selection || flags.variant || flags.catalog_variant_id || flags.item || flags.catalog_item_id;
   if (!selectionID) throw new Error("catalog variant id is required, for example: itp buy var_pubg_couple_skin_cny20 --sandbox --email buyer@example.com --phone +8613800000000 --json");
   const selection = await resolveBuyerCatalogSelection(selectionID, flags);
@@ -14,7 +15,7 @@ async function buyerBuy(flags) {
   let checkout = await createBuyerCheckoutFromCart(cart, selection, flags);
   if (checkout.next_required_action === "auth_qr" || checkout.identity_status === "waiting_human_auth") {
     await renderHumanAction(checkout.human_action, flags);
-    if (flags.no_wait || flags.no_wait_auth) {
+    if (flags.no_wait || flags.no_wait_auth || showThenWait) {
       output(buyerRunOutput({
         status: "waiting_human_auth",
         selection,
@@ -41,15 +42,20 @@ async function buyerBuy(flags) {
     : await createBuyerPaymentIntent(checkout.checkout_id, flags);
   await renderItPayPaymentAction(intent, flags);
 
-  if (flags.no_wait || flags.no_wait_payment) {
+  if (flags.no_wait || flags.no_wait_payment || showThenWait) {
     output(buyerRunOutput({
       status: "waiting_user_payment",
       selection,
       cart,
       checkout,
       payment_intent: intent,
+      payment_handoff: paymentHandoff(intent),
       agent_next_actions: intent.agent_next_actions || ["wait_payment"],
-      next: { command: cliCommand("buyer", "payment", "wait", intent.payment_intent_id, "--json") }
+      next: {
+        command: paymentWaitCommand(intent.payment_intent_id, { short: true }),
+        safe_for_agent: true,
+        instruction: "Send payment_handoff.markdown to the human first, then run this wait command unless the human explicitly asked you to pause."
+      }
     }));
     return;
   }
@@ -312,8 +318,16 @@ async function buyer(command, rest, flags) {
             status: intent.status === "verified" ? "payment_verified" : "waiting_user_payment",
             checkout,
             payment_intent: intent,
+            payment_handoff: intent.status === "verified" ? undefined : paymentHandoff(intent),
             buyer_session: buyerSessionClaimStatus(claimedSession),
-            agent_next_actions: intent.agent_next_actions || checkout.agent_next_actions || ["wait_payment"]
+            agent_next_actions: intent.agent_next_actions || checkout.agent_next_actions || ["wait_payment"],
+            next: intent.status === "verified"
+              ? { command: cliCommand("buyer", "checkout", "status", checkout.checkout_id, "--json"), safe_for_agent: true }
+              : {
+                command: paymentWaitCommand(intent.payment_intent_id, { short: true }),
+                safe_for_agent: true,
+                instruction: "Send payment_handoff.markdown to the human first, then run this wait command unless the human explicitly asked you to pause."
+              }
           }));
           return;
         }
@@ -326,7 +340,18 @@ async function buyer(command, rest, flags) {
         }
         const intent = await createBuyerPaymentIntent(checkout.checkout_id, flags);
         await renderItPayPaymentAction(intent, flags);
-        output(buyerRunOutput({ status: "waiting_user_payment", checkout, payment_intent: intent, agent_next_actions: intent.agent_next_actions || ["wait_payment"] }));
+        output(buyerRunOutput({
+          status: "waiting_user_payment",
+          checkout,
+          payment_intent: intent,
+          payment_handoff: paymentHandoff(intent),
+          agent_next_actions: intent.agent_next_actions || ["wait_payment"],
+          next: {
+            command: paymentWaitCommand(intent.payment_intent_id, { short: true }),
+            safe_for_agent: true,
+            instruction: "Send payment_handoff.markdown to the human first, then run this wait command unless the human explicitly asked you to pause."
+          }
+        }));
         return;
       }
       output(buyerRunOutput({
@@ -367,11 +392,16 @@ async function buyer(command, rest, flags) {
     output(buyerRunOutput({
       status: refreshed.status === "verified" ? "payment_verified" : "waiting_user_payment",
       payment_intent: refreshed,
+      payment_handoff: refreshed.status === "verified" ? undefined : paymentHandoff(refreshed),
       payment_guidance: paymentRecoveryGuidance(refreshed, { event_type: refreshed.status === "verified" ? "payment_intent.verified" : "qr_refreshed" }),
       agent_next_actions: refreshed.agent_next_actions || paymentAgentNextActions(refreshed, { event_type: refreshed.status === "verified" ? "payment_intent.verified" : "qr_refreshed" }),
       next: refreshed.status === "verified"
         ? { command: cliCommand("buyer", "checkout", "status", refreshed.checkout_id, "--json"), safe_for_agent: true }
-        : { command: cliCommand("buyer", "payment", "wait", refreshed.payment_intent_id, "--json"), safe_for_agent: true }
+        : {
+          command: paymentWaitCommand(refreshed.payment_intent_id, { short: true }),
+          safe_for_agent: true,
+          instruction: "Send payment_handoff.markdown to the human first, then run this wait command unless the human explicitly asked you to pause."
+        }
     }));
     return;
   }
@@ -997,6 +1027,49 @@ function paymentAgentNextActions(intent = {}, event = {}) {
   return ["show_payment_qr_if_needed", "wait_same_payment_intent"];
 }
 
+function paymentHandoff(intent = {}) {
+  const action = intent.human_action || {};
+  const paymentIntentID = intent.payment_intent_id || action.id || "";
+  const entryURL = intent.payment_entry_url || intent.payment_url || action.url || "";
+  const qrPNGURL = action.qr_png_url || intent.qr_png_url || intent.qr?.png_url || "";
+  const preferredQRURL = action.preferred_qr_url || qrPNGURL || action.qr_image_url || intent.qr_image_url || intent.qr?.image_url || "";
+  const localQRPath = action.local_qr_path || intent.local_qr_path || "";
+  const mobileWalletURL = action.mobile_wallet_url || intent.mobile_wallet_url || "";
+  const waitCommand = paymentWaitCommand(paymentIntentID, { short: true });
+  return {
+    type: "payment_qr_handoff",
+    payment_intent_id: paymentIntentID || null,
+    checkout_id: intent.checkout_id || null,
+    primary: localQRPath ? "local_qr_path" : (qrPNGURL ? "qr_png_url" : (preferredQRURL ? "preferred_qr_url" : "payment_entry_url")),
+    local_qr_path: localQRPath || null,
+    qr_png_url: qrPNGURL || null,
+    preferred_qr_url: preferredQRURL || null,
+    payment_entry_url: entryURL || null,
+    mobile_wallet_url: mobileWalletURL || null,
+    markdown: paymentHandoffMarkdown({ localQRPath, qrPNGURL, preferredQRURL, entryURL, mobileWalletURL }),
+    wait_command: waitCommand || null,
+    safe_for_agent: true,
+    instruction: "Show markdown to the human first. Then run wait_command and wait for payment_intent.verified unless the human asked you to pause."
+  };
+}
+
+function paymentHandoffMarkdown({ localQRPath = "", qrPNGURL = "", preferredQRURL = "", entryURL = "", mobileWalletURL = "" } = {}) {
+  const imageURL = localQRPath || qrPNGURL || preferredQRURL;
+  const lines = ["请扫码付款："];
+  if (imageURL) lines.push(`![ItPay payment QR](${imageURL})`);
+  if (entryURL) lines.push(`[打开付款页面](${entryURL})`);
+  if (mobileWalletURL) lines.push(`[手机钱包打开](${mobileWalletURL})`);
+  lines.push("我会继续等待 ItPay 返回 payment_intent.verified。");
+  return lines.join("\n\n");
+}
+
+function paymentWaitCommand(paymentIntentID, { short = false } = {}) {
+  if (!paymentIntentID) return "";
+  return short
+    ? cliCommand("buyer", "payment", "wait", paymentIntentID, "--timeout", "60", "--json")
+    : cliCommand("buyer", "payment", "wait", paymentIntentID, "--json");
+}
+
 function paymentRecoveryGuidance(intent = {}, event = {}) {
   const paymentIntentID = intent.payment_intent_id || event.payment_intent_id || null;
   return {

package/lib/render-human.js

@@ -8,7 +8,7 @@ import { apiTimeoutMs, cliCommand, commandExists, mergeRun, readRun, readState,
 async function renderItPayPaymentAction(intent, flags = {}) {
   const action = intent?.human_action ? { ...intent.human_action } : (intent?.payment_url ? {
     id: intent.payment_intent_id,
-    title: "Scan with Alipay",
+    title: "Scan payment QR",
     url: intent.payment_url,
     expires_at: intent.qr?.expires_at
   } : null);
@@ -23,7 +23,7 @@ async function renderItPayPaymentAction(intent, flags = {}) {
   if (action && (intent?.qr_image_url || intent?.qr?.image_url)) {
     action.qr_image_url = intent.qr_image_url || intent.qr.image_url;
     action.display_mode = intent.qr?.scan_mode || "itpay_entry_qr";
-    action.description = action.description || "Scan the ItPay payment entry QR; ItPay will safely hand off to Alipay.";
+    action.description = action.description || "Scan the ItPay payment entry QR; ItPay will safely hand off to the payment provider.";
   }
   const result = await renderHumanAction(action, flags);
   if (intent && action) {
@@ -39,7 +39,7 @@ function humanActionSummaryLines(action) {
   if (!action?.url) return [];
   const lines = [
     "ITP HUMAN ACTION REQUIRED",
-    `Title: ${action.title || "Scan with Alipay"}`,
+    `Title: ${humanActionTitle(action)}`,
     `URL: ${action.url}`
   ];
   if (action.local_qr_path) {
@@ -55,7 +55,7 @@ function humanActionSummaryLines(action) {
     lines.push(`Mobile wallet link: ${action.mobile_wallet_url}`);
   }
   if (action.oauth_start_url) {
-    lines.push(`Alipay auth fallback: ${action.oauth_start_url}`);
+    lines.push(`${humanActionProviderLabel(action)} auth fallback: ${action.oauth_start_url}`);
   }
   if (action.fallback_text && !action.fallback_text.includes(action.url)) {
     lines.push(`Fallback: ${action.fallback_text}`);
@@ -89,7 +89,7 @@ function writeWaitHeartbeat({ kind, idName, idValue, status, action, lastHeartbe
     action?.qr_png_url ? `QR PNG: ${action.qr_png_url}` : null,
     action?.qr_image_url ? `QR image: ${action.qr_image_url}` : null,
     action?.mobile_wallet_url ? `Mobile wallet link: ${action.mobile_wallet_url}` : null,
-    action?.oauth_start_url ? `Alipay auth fallback: ${action.oauth_start_url}` : null,
+    action?.oauth_start_url ? `${humanActionProviderLabel(action)} auth fallback: ${action.oauth_start_url}` : null,
     command ? `Resume command: ${command}` : null
   ].filter(Boolean);
   process.stderr.write(`\n${lines.join("\n")}\n\n`);
@@ -121,7 +121,7 @@ async function renderHumanAction(action, flags = {}) {
     }
     return { rendered: false, mode: flags.json ? "json" : mode };
   }
-  const host = String(process.env.ITP_HOST || flags.host || "").toLowerCase();
+  const host = agentHost(flags);
   if (["discord", "telegram", "whatsapp"].includes(host)) {
     return { rendered: false, mode: "chat-json", host };
   }
@@ -147,9 +147,29 @@ async function renderHumanAction(action, flags = {}) {
   }
 
   const renderResult = { rendered: false, mode, outputs: [] };
+  const terminalQRAllowed = shouldRenderTerminalQR(host, mode);
+  const providerLabel = humanActionProviderLabel(action);
+  const actionTitle = humanActionTitle(action);
   writeHumanActionSummary(action);
+
+  if ((mode === "auto" || mode === "terminal") && terminalQRAllowed) {
+    const qr = await QRCode.toString(action.url, {
+      type: terminalQRType(flags, host),
+      small: true,
+      errorCorrectionLevel: "M"
+    });
+    process.stderr.write(`\n${actionTitle}\n`);
+    if (action.description) process.stderr.write(`${action.description}\n`);
+    process.stderr.write(`${qr}\n`);
+    process.stderr.write(`${providerLabel} action URL: ${action.url}\n`);
+    if (action.expires_at) process.stderr.write(`Expires at: ${formatActionTime(action.expires_at)}\n`);
+    renderResult.rendered = true;
+    renderResult.outputs.push("terminal");
+    return renderResult;
+  }
+
   if ((mode === "auto" || mode === "browser") && shouldOpenBrowser(flags)) {
-    if (openBrowser(action.mobile_wallet_url || qrImageURL || action.url)) {
+    if (openBrowser(qrImageURL || action.mobile_wallet_url || action.url)) {
       renderResult.rendered = true;
       renderResult.outputs.push("browser");
     }
@@ -162,7 +182,7 @@ async function renderHumanAction(action, flags = {}) {
       await downloadQRImage(qrImageURL, file, flags);
       action.local_qr_path = file;
       action.local_qr_mime = qrMimeType(qrImageURL, action);
-      process.stderr.write(`Alipay QR image: ${file}\n`);
+      process.stderr.write(`${providerLabel} QR image: ${file}\n`);
       renderResult.rendered = true;
       renderResult.outputs.push(file);
       if (mode === "file") return renderResult;
@@ -173,44 +193,42 @@ async function renderHumanAction(action, flags = {}) {
       if (localPath) {
         attachAgentLocalQR(action, localPath);
         annotateHumanActionPresentation(action, "");
-        process.stderr.write(`Alipay action QR image: ${localPath}\n`);
+        process.stderr.write(`${providerLabel} action QR image: ${localPath}\n`);
         renderResult.rendered = true;
         renderResult.outputs.push(localPath);
         if (mode === "file") return renderResult;
       } else {
-        process.stderr.write(`No QR image available. Open action URL: ${action.url}\n`);
+        process.stderr.write(`No branded QR image available. Open action URL: ${action.url}\n`);
       }
     }
   }
 
   if (qrImageURL) {
-    process.stderr.write(`Alipay QR image URL: ${qrImageURL}\n`);
+    process.stderr.write(`${providerLabel} QR image URL: ${qrImageURL}\n`);
     if (action.mobile_wallet_url) process.stderr.write(`Mobile wallet link: ${action.mobile_wallet_url}\n`);
     renderResult.outputs.push("preferred_qr_url");
     return renderResult;
   }
 
-  if ((mode === "auto" || mode === "terminal") && shouldRenderTerminalQR(host)) {
-    const qr = await QRCode.toString(action.url, {
-      type: terminalQRType(flags, host),
-      small: true,
-      errorCorrectionLevel: "M"
-    });
-    process.stderr.write(`\n${action.title || "Scan with Alipay"}\n`);
-    if (action.description) process.stderr.write(`${action.description}\n`);
-    process.stderr.write(`${qr}\n`);
-    process.stderr.write(`Alipay action URL: ${action.url}\n`);
-    if (action.expires_at) process.stderr.write(`Expires at: ${formatActionTime(action.expires_at)}\n`);
-    renderResult.rendered = true;
-    renderResult.outputs.push("terminal");
-    return renderResult;
-  }
-
-  process.stderr.write(`${action.fallback_text || `Open Alipay URL: ${action.url}`}\n`);
+  process.stderr.write(`${action.fallback_text || `Open ${providerLabel} URL: ${action.url}`}\n`);
   renderResult.outputs.push("url");
   return renderResult;
 }
 
+function humanActionTitle(action = {}) {
+  if (action.title) return action.title;
+  if (action.kind === "auth_qr") return `${humanActionProviderLabel(action)} authentication`;
+  return "Scan payment QR";
+}
+
+function humanActionProviderLabel(action = {}) {
+  const raw = String(action.provider || action.channel || action.display_mode || "").toLowerCase();
+  if (raw.includes("alipay")) return "Alipay";
+  if (raw.includes("wechat")) return "WeChat Pay";
+  if (raw.includes("fake") || raw.includes("local")) return "ItPay local";
+  return "Alipay or WeChat Pay";
+}
+
 function preferredHumanActionQRURL(action) {
   return action?.qr_png_url ||
     humanActionPresentationURL(action, "qr_png_url") ||
@@ -338,8 +356,8 @@ function formatActionTime(value) {
 
 function shouldUseAgentTextQR(flags = {}) {
   const mode = String(flags.display || process.env.ITP_DISPLAY || "").toLowerCase() || "auto";
-  const host = String(process.env.ITP_HOST || flags.host || "").toLowerCase();
-  return mode === "chat" || mode === "agent" || (["gemini", "gemini-cli"].includes(host) && mode === "auto");
+  const host = agentHost(flags);
+  return mode === "chat" || mode === "agent" || (agentTextQRHosts().has(host) && mode === "auto");
 }
 
 function shouldReturnAfterAgentTextQR(flags = {}) {
@@ -347,6 +365,18 @@ function shouldReturnAfterAgentTextQR(flags = {}) {
   return shouldUseAgentTextQR(flags);
 }
 
+function agentHost(flags = {}) {
+  const explicit = String(process.env.ITP_HOST || flags.host || "").toLowerCase();
+  if (explicit) return explicit;
+  if (process.env.CODEX_THREAD_ID || process.env.CODEX_SHELL || process.env.CODEX_CI) return "codex";
+  if (process.env.CLAUDECODE || process.env.CLAUDE_CODE || process.env.CLAUDECODE_SESSION_ID) return "claude-code";
+  return "";
+}
+
+function agentTextQRHosts() {
+  return new Set(["codex", "codex-cli", "claude", "claude-code", "gemini", "gemini-cli"]);
+}
+
 function attachAgentQRImage(action, qrImageURL, localPath = "") {
   if (!action || !qrImageURL) return action;
   action.preferred_qr_url = qrImageURL;
@@ -416,16 +446,22 @@ function persistHumanAction(action, flags = {}) {
   writeRun(mergeRun(run, { human_action: action }));
 }
 
-function shouldRenderTerminalQR(host) {
+function shouldRenderTerminalQR(host, mode = "auto") {
+  if (["terminal", "tty"].includes(mode)) return true;
+  if (mode && !["auto", ""].includes(mode)) return false;
   if (process.stderr.isTTY) return true;
-  return ["gemini", "gemini-cli"].includes(host);
+  return terminalQRHostAliases().has(String(host || "").toLowerCase());
+}
+
+function terminalQRHostAliases() {
+  return new Set(["terminal", "tty", "bash", "zsh", "sh", "shell", "iterm", "iterm2"]);
 }
 
 function terminalQRType(flags = {}, host = "") {
   const requested = String(flags.qr_format || process.env.ITP_QR_FORMAT || "").toLowerCase();
   if (requested === "unicode" || requested === "utf8") return "utf8";
   if (requested === "ansi" || requested === "terminal") return "terminal";
-  if (["gemini", "gemini-cli"].includes(host)) return "utf8";
+  if (terminalQRHostAliases().has(String(host || "").toLowerCase())) return "utf8";
   return "terminal";
 }
 

package/lib/runtime.js

@@ -7,6 +7,7 @@ import {
   recoverableBuyerContextForStatus, recoverableIntentCheckGuidance
 } from "./buyer.js";
 import { renderHumanAction, shouldReturnAfterAgentTextQR, writeWaitHeartbeat } from "./render-human.js";
+import { accountOverviewStatus, nextActionForAuthStatus, outputAccountStatus, refreshBuyerSessionForStatus } from "./account-status.js";
 import {
   CREDENTIALS_PATH, CONFIG_DIR, RUNS_DIR, VERSION, apiBase, apiTimeoutMs, appendURLQuery, booleanFlag, cliCommand, commandExists,
   cryptoRandom, csvValues, currentExecutable, deleteGrantCredential, deleteSessionCredential, detectNativeCredentialStore,
@@ -131,14 +132,14 @@ async function setup(flags) {
         grant_id: checkout.grant_id || run.grant?.grant_id || null
       },
       human_action: checkout.human_action || null,
-      safe_summary: checkout.grant_id ? "Payment verified and grant is ready." : "Waiting for Alipay payment scan."
+      safe_summary: checkout.grant_id ? "Payment verified and grant is ready." : "Waiting for Alipay or WeChat Pay payment scan."
     });
     writeRun(run);
 
     if (checkout.human_action) {
       await renderHumanAction(checkout.human_action, setupFlags);
     } else if (checkout.payment?.cashier_url) {
-      process.stderr.write(`Open Alipay payment URL: ${checkout.payment.cashier_url}\n`);
+      process.stderr.write(`Open Alipay or WeChat Pay payment URL: ${checkout.payment.cashier_url}\n`);
     }
 
     if (!checkout.grant_id && (setupFlags.no_wait_payment || setupFlags.no_wait)) {
@@ -263,40 +264,7 @@ async function agentStatus(flags) {
   const runId = flags.run_id || readState().current_run_id;
   const run = readRun(runId);
   if (!run) {
-    const config = readConfig();
-    const credentials = readCredentials();
-    const hasLocalSession = Boolean(readSessionToken(credentials));
-    const auth = flags.refresh
-      ? await refreshBuyerSessionForStatus(flags)
-      : {
-          authenticated: hasLocalSession,
-          session_verified: false,
-          account_id: config.account_id || null,
-          device_id: config.device_id || null,
-          auth_source: hasLocalSession ? "local_files_unverified" : "local_files"
-        };
-    output({
-      schema_version: "itp.agent.v1",
-      status: auth.authenticated
-        ? (auth.session_verified === false ? "local_session_unverified" : "idle")
-        : "unauthenticated",
-      phase: auth.authenticated ? "idle" : "unauthenticated",
-      authenticated: Boolean(auth.authenticated),
-      session_verified: auth.session_verified !== false,
-      auth_source: auth.auth_source,
-      account_id: auth.account_id || null,
-      device_id: auth.device_id || null,
-      next: nextActionForAuthStatus(auth, flags),
-      recoverable_context: noRecoverableContext(),
-      agent_next_actions: auth.authenticated && auth.session_verified !== false
-        ? ["search_catalog", "view_orders", "create_refund_if_needed", "list_agent_read_grants"]
-        : ["run_status_refresh", "start_human_auth_if_unauthenticated"],
-      note: auth.authenticated && auth.session_verified === false
-        ? "Local buyer session exists but the server has not verified it. Run the next.command before order/refund/account operations."
-        : undefined,
-      error: auth.error || undefined,
-      secrets: { raw_key_included: false, session_token_included: false }
-    });
+    outputAccountStatus(await accountOverviewStatus(flags), flags);
     return;
   }
   const refreshed = flags.refresh ? await refreshRun(run, flags) : run;
@@ -306,50 +274,6 @@ async function agentStatus(flags) {
   }));
 }
 
-async function refreshBuyerSessionForStatus(flags = {}) {
-  const config = readConfig();
-  const credentials = readCredentials();
-  if (!readSessionToken(credentials)) {
-    return {
-      authenticated: false,
-      session_verified: true,
-      account_id: config.account_id || null,
-      device_id: config.device_id || null,
-      auth_source: "core_no_session"
-    };
-  }
-  try {
-    const status = await coreApi("/v1/me/auth/status", { method: "GET" }, flags);
-    return {
-      authenticated: true,
-      session_verified: true,
-      account_id: status.buyer_account_id || config.account_id || null,
-      device_id: config.device_id || null,
-      account_status: status.account_status || null,
-      auth_source: "core"
-    };
-  } catch (error) {
-    return {
-      authenticated: false,
-      session_verified: true,
-      account_id: config.account_id || null,
-      device_id: config.device_id || null,
-      auth_source: "core",
-      error: safeErrorMessage(error)
-    };
-  }
-}
-
-function nextActionForAuthStatus(auth = {}, flags = {}) {
-  if (auth.authenticated && auth.session_verified === false) {
-    return { type: "verify_buyer_session", command: cliCommand("status", "--refresh", "--json"), safe_for_agent: true };
-  }
-  if (auth.authenticated) {
-    return { type: "buyer_ready", command: cliCommand("buyer", "auth", "status", "--json"), safe_for_agent: true };
-  }
-  return { type: "start_auth", command: cliCommand("setup", "--plan", "credit-300", "--method", "alipay", "--json"), safe_for_agent: true };
-}
-
 async function resume(flags) {
   const runId = flags.run_id || readState().current_run_id;
   const run = readRun(runId);
@@ -761,7 +685,7 @@ async function createCheckoutResult(flags) {
       grant_id: response.grant_id || currentRun?.grant?.grant_id || null
     },
     human_action: response.human_action || null,
-    safe_summary: response.grant_id ? "Payment verified and grant is ready." : "Waiting for Alipay payment scan."
+    safe_summary: response.grant_id ? "Payment verified and grant is ready." : "Waiting for Alipay or WeChat Pay payment scan."
   }, flags);
   return response;
 }
@@ -827,7 +751,7 @@ async function paymentWaitResult(checkoutId, flags) {
       }
     }
     lastHeartbeatAt = writeWaitHeartbeat({
-      kind: "Alipay payment",
+      kind: "Alipay or WeChat Pay payment",
       idName: "checkout_id",
       idValue: checkoutId,
       status: response.status || "waiting",
@@ -1376,7 +1300,7 @@ async function refreshRun(run, flags = {}) {
         payment: { provider: next.payment_method, status: checkout.status },
         grant: { ...(next.grant || {}), grant_id: checkout.grant_id || next.grant?.grant_id || null },
         human_action: checkout.human_action || null,
-        safe_summary: checkout.grant_id ? "Payment verified and grant is ready." : checkout.status === "waiting_user_payment" ? "Waiting for Alipay payment scan." : `Checkout status: ${checkout.status}`
+        safe_summary: checkout.grant_id ? "Payment verified and grant is ready." : checkout.status === "waiting_user_payment" ? "Waiting for Alipay or WeChat Pay payment scan." : `Checkout status: ${checkout.status}`
       });
     } catch (error) {
       next = mergeRun(next, { last_error: safeErrorMessage(error), safe_summary: "Could not refresh checkout status." });
@@ -1498,7 +1422,7 @@ function appendPassthroughFlag(args, flags, key, flagName = key) {
 
 function safeUserMessageForRun(run) {
   if (run.phase === "waiting_human_auth") return "Please scan the Alipay authentication QR. I will continue automatically after approval.";
-  if (run.phase === "waiting_human_payment") return "Please scan the Alipay payment QR. I will continue automatically after payment is verified.";
+  if (run.phase === "waiting_human_payment") return "Please scan the Alipay or WeChat Pay payment QR. I will continue automatically after payment is verified.";
   if (run.grant?.installed) return "Payment verified. The API credential is stored locally.";
   return run.safe_summary || "ITPay setup is in progress.";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itpay/cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "ItPay CLI, buyer skill, and agent-readable docs for agent-native commerce.",
   "type": "module",
   "bin": {

package/skills/itpay-buyer/SKILL.md

@@ -59,7 +59,7 @@ read this skill
 The high-level command can wrap this flow:
 
 ```bash
-itp buy <variant_id> --sandbox --email <buyer_email> --phone <buyer_phone> --json
+itp buy <variant_id> --sandbox --email <buyer_email> --phone <buyer_phone> --display agent --no-wait-payment --json
 ```
 
 For step-by-step testing:
@@ -93,7 +93,7 @@ itp buyer cart create --variant var_itpay_enterprise_fuzzy_search_cny01 --input
 itp buyer cart show <cart_id> --json
 itp buyer cart add <cart_id> --variant var_itpay_enterprise_fuzzy_search_cny01 --input company_name=美团 --json
 itp buyer cart create --variant var_itpay_enterprise_precise_lookup_cny05 --input company_name_or_credit_no=北京京东世纪贸易有限公司 --json
-itp buy var_itpay_enterprise_fuzzy_search_cny01 --sandbox --email <buyer_email> --input company_name=京东 --json
+itp buy var_itpay_enterprise_fuzzy_search_cny01 --sandbox --email <buyer_email> --input company_name=京东 --display agent --no-wait-payment --json
 ```
 
 For cart edits, always read the server cart first with `buyer cart show`.
@@ -206,13 +206,16 @@ Each docs page includes `next_docs`. Follow those links as the state changes.
 For payment creation in an agent/chat client, prefer:
 
 ```bash
-itp buy <variant_id> --sandbox --email <buyer_email> --phone <buyer_phone> --display agent --json
+itp buy <variant_id> --sandbox --email <buyer_email> --phone <buyer_phone> --display agent --no-wait-payment --json
 ```
 
 This keeps JSON output machine-readable while allowing the CLI to prepare a
-local QR image path for clients that cannot render remote SVG reliably. If the
-human is on mobile, present `mobile_wallet_url` as a clickable human-only
-fallback; do not convert it into a QR.
+local QR image path for clients that cannot render remote SVG reliably. In
+Codex or Claude Code app clients, prefer `--no-wait-payment`: send
+`payment_handoff.markdown` to the human first, then run
+`payment_handoff.wait_command`. If the human is on mobile, present
+`mobile_wallet_url` as a clickable human-only fallback; do not convert it into a
+QR.
 
 For first-purchase auth, treat the returned ItPay authorization entry as a
 single human orchestration entry. It may open Alipay login/registration first